home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / c / gcc / gempp19.zoo / gem++19 / src / gemhf.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-20  |  14.7 KB  |  593 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  This file is Copyright 1992,1993 by Warwick W. Allison.
  4. //  This file is part of the gem++ library.
  5. //  You are free to copy and modify these sources, provided you acknowledge
  6. //  the origin by retaining this notice, and adhere to the conditions
  7. //  described in the file COPYING.LIB.
  8. //
  9. /////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include <aesbind.h>
  12. #include <values.h>
  13. #include "gemhf.h"
  14. #include "gemrawo.h"
  15. #include "grect.h"
  16.  
  17.  
  18. static int FindEdit(GEMrawobject* o, int i)
  19. {
  20.     return o[i].Editable() ? i : -1;
  21. }
  22.  
  23. GEMhotform::GEMhotform(const GEMrsc& in, int RSCindex) :
  24.     GEMform(in,RSCindex)
  25. {
  26.     curedit=Map(FindEdit);
  27.     Zooms(FALSE);
  28. }
  29.  
  30. GEMhotform::GEMhotform(const GEMhotform& copy) :
  31.     GEMform(copy)
  32. {
  33.     curedit=Map(FindEdit);
  34.     Zooms(FALSE);
  35. }
  36.  
  37. int GEMhotform::DoKey(int meta, int key)
  38. {
  39.     return Ignore;
  40. }
  41.  
  42. int GEMhotform::DoOff()
  43. {
  44.     return NoObject;
  45. }
  46.  
  47. int GEMhotform::DoHot(int ob, bool inside)
  48. {
  49.     static void objc_toggle(GEMrawobject* tree, int obj);
  50.  
  51.     objc_toggle(Obj,ob);
  52.  
  53.     // Could use this, but G_STRING objects are transparent, so do not
  54.     // Redraw well when selected.
  55.     //
  56.     // Obj[ob].Selected(inside);
  57.     // RedrawObject(ob);
  58.  
  59.     return Ignore;
  60. }
  61.  
  62. // "Hot" version from Profesional GEM, by Tim Oren.
  63. //
  64. // The following code is based on the file "gemcl13.c" in the
  65. // source code provided with the Professional GEM series.
  66. // Available in the /atari/Programming directory of atari.archive.umich.edu.
  67. //
  68. // Changes include:
  69. //
  70. //      - Ported to C++ (ie. uses ANSI prototypes).
  71. //      - Uses current bindings.
  72. //      - Added "machine" macros #defines at start.
  73. //      - Clicking off form detected.
  74. //      - Unprocessed keys passed to DoKey() method.
  75.  
  76. #define NIL -1
  77.  
  78. #define    M1_ENTER    0x0000
  79. #define    M1_EXIT        0x0001
  80.  
  81. #define BS   0x0008
  82. #define    TAB  0x0009
  83. #define    CR   0x000D
  84. #define ESC  0x001B
  85. #define    BTAB 0x0f00
  86. #define    UP   0x4800
  87. #define    DOWN 0x5000
  88. #define    DEL  0x5300
  89.  
  90. /* Global variables used by */
  91. /* 'mapped' functions        */
  92.  
  93. static    GRect    br_rect;        /* Current break rectangle  */
  94. static    int    br_mx, br_my, br_togl;    /* Break mouse posn & flag  */ 
  95. static    int    fn_obj;            /* Found tabable object        */
  96. static    int    fn_last;        /* Object tabbing from        */
  97. static    int    fn_prev;        /* Last EDITABLE obj seen   */
  98. static    int    fn_dir;            /* 1 = TAB, 0 = BACKTAB        */
  99.  
  100. /************* Utility routines for new forms manager ***************/
  101.  
  102. /* Return the object's GRect through 'p' */
  103. static void objc_xywh(GEMrawobject* tree, int obj, GRect *p)
  104. {
  105.     objc_offset(tree, obj, &p->g_x, &p->g_y);
  106.     p->g_w = tree[obj].Width();
  107.     p->g_h = tree[obj].Height();
  108. }
  109.  
  110. /* Reverse the SELECT state */
  111. static void objc_toggle(GEMrawobject* tree, int obj)
  112. {
  113.     int    state, newstate;
  114.     GRect    root;
  115.  
  116.     objc_xywh(tree, ROOT, &root);
  117.     state = tree[obj].States();
  118.     newstate = state ^ SELECTED;
  119.     objc_change(tree, obj, 0, root.g_x, root.g_y, 
  120.         root.g_w, root.g_h, newstate, 1);
  121. }
  122.  
  123. /* If the object is not already SELECTED, make it so. */
  124. static void objc_sel(GEMrawobject* tree, int obj)
  125. {
  126.     if ( !(tree[obj].States() & SELECTED) )
  127.         objc_toggle(tree, obj);
  128. }
  129.  
  130. /* If the object is SELECTED, deselect it. */
  131. static void objc_dsel(GEMrawobject* tree, int obj)
  132. {
  133.     if (tree[obj].States() & SELECTED)
  134.         objc_toggle(tree, obj);
  135. }
  136.  
  137. /* Non-cursive traverse of an object tree. */
  138. static void map_tree(GEMrawobject* tree, int this1, int last, int routine(GEMrawobject*,int))
  139. {
  140.     int        tmp1;
  141.  
  142.     tmp1 = this1;        /* Initialize to impossible value: */
  143.                 /* TAIL won't point to self!       */
  144.                 /* Look until final node, or off   */
  145.                 /* the end of tree           */ 
  146.     while (this1 != last && this1 != NIL)
  147.                 /* Did we 'pop' into this1 node       */
  148.                 /* for the second time?           */
  149.         if (tree[this1].Tail() != tmp1)
  150.             {
  151.             tmp1 = this1;    /* This is a new node       */
  152.             this1 = NIL;
  153.                     /* Apply operation, testing  */
  154.                     /* for rejection of sub-tree */
  155.             if (!tree[tmp1].HideTree())
  156.                 if (routine(tree, tmp1))
  157.                     this1 = tree[tmp1].Head();
  158.                     /* Subtree path not taken,   */
  159.                     /* so traverse right         */    
  160.             if (this1 == NIL)
  161.                 this1 = tree[tmp1].Next();
  162.             }
  163.         else            /* Revisiting parent:          */
  164.                     /* No operation, move right  */
  165.             {
  166.             tmp1 = this1;
  167.             this1 = tree[tmp1].Next();
  168.             }
  169. }
  170.  
  171. /* Find the parent of an object of by traversing right */
  172. static int get_parent(GEMrawobject* tree, int obj)
  173. {
  174.     int        pobj;
  175.  
  176.     if (obj == NIL)
  177.         return (NIL);
  178.     pobj = tree[obj].Next();
  179.     if (pobj != NIL)
  180.     {
  181.       while( tree[pobj].Tail() != obj ) 
  182.       {
  183.         obj = pobj;
  184.         pobj = tree[obj].Next();
  185.       }
  186.     }
  187.     return(pobj);
  188. } 
  189.  
  190. /* determine if x,y is in rectangle    */
  191. static int inside(int x, int y, GRect *pt)    
  192. {
  193.     if ( (x >= pt->g_x) && (y >= pt->g_y) &&
  194.         (x < pt->g_x + pt->g_w) && (y < pt->g_y + pt->g_h) )
  195.         return(TRUE);
  196.     else
  197.         return(FALSE);
  198. } 
  199.  
  200. /************* "Hot-spot" manager and subroutines  ***************/
  201.  
  202. static int break_x(int *pxy)
  203. {                /* Breaking object is right of    */
  204.     if (br_mx < pxy[0])        /* mouse.  Reduce width of     */
  205.         {            /* bounding rectangle.        */
  206.         br_rect.g_w = pxy[0] - br_rect.g_x;
  207.         return (TRUE);
  208.         }
  209.     if (br_mx > pxy[2])        /* Object to left.  Reduce width*/
  210.         {            /* and move rect. to right    */
  211.         br_rect.g_w += br_rect.g_x - pxy[2] - 1;
  212.         br_rect.g_x = pxy[2] + 1;
  213.         return (TRUE);
  214.         }
  215.     return (FALSE);            /* Mouse within object segment.    */
  216. }                /* Break attempt fails.        */
  217.  
  218. static int break_y(int *pxy)
  219. {
  220.     if (br_my < pxy[1])        /* Object below mouse.  Reduce    */
  221.         {            /* height of bounding rect.    */
  222.         br_rect.g_h = pxy[1] - br_rect.g_y;
  223.         return (TRUE);
  224.         }
  225.     if (br_my > pxy[3])        /* Object above mouse.  Reduce    */
  226.         {            /* height and shift downward.    */
  227.         br_rect.g_h += br_rect.g_y - pxy[3] - 1;
  228.         br_rect.g_y = pxy[3] + 1;
  229.         return (TRUE); 
  230.         }
  231.     /* Emergency escape test! Protection vs. turkeys who nest */
  232.     /* non-selectable objects inside of selectables.          */
  233.     if (br_mx >= pxy[0] && br_mx <= pxy[1])
  234.         {                /* Will X break fail?      */
  235.         br_rect.g_x = br_mx;        /* If so, punt!          */
  236.         br_rect.g_y = br_my;
  237.         br_rect.g_w = br_rect.g_h = 1;
  238.         return (TRUE);
  239.         }
  240.     return (FALSE);
  241. }
  242.  
  243. /* Called once per object to    */
  244. static int break_obj(GEMrawobject* tree, int obj)
  245. {
  246.     GRect    s;
  247.     int    flags, broken, pxy[4];
  248.  
  249.     objc_xywh(tree, obj, &s);
  250.     grect_to_array(&s, pxy);
  251.     if (!rc_intersect(&br_rect, &s))
  252.         return (FALSE);        /* Trivial rejection case     */
  253.  
  254.     flags = tree[obj].Flags();    /* Is this1 object a potential    */
  255.     if (flags & HIDETREE)        /* hot-spot?                 */
  256.         return (FALSE);
  257.     if ( !(flags & SELECTABLE) )
  258.         return (TRUE);
  259.     if (tree[obj].States() & DISABLED)
  260.         return (TRUE);
  261.  
  262.     for (broken = FALSE; !broken; ) /* This could take two passes     */
  263.         {            /* if the first break fails.       */
  264.         if (br_togl)
  265.             broken = break_x(pxy);
  266.         else
  267.             broken = break_y(pxy);
  268.         br_togl = !br_togl;
  269.         }
  270.     return (TRUE);
  271. }
  272.  
  273. /* Manages mouse rectangle events */
  274. static int form_hot(GEMrawobject* tree, int hot_obj, int mx, int my, GRect *rect, int *mode)
  275. {
  276.     GRect    root;
  277.     int    state;
  278.  
  279.     objc_xywh(tree, ROOT, &root);    /* If there is already a hot-spot */
  280.  
  281.     if (!(inside(mx, my, &root)) )    /* Mouse has moved outside of       */
  282.         {            /* the dialog.  Wait for return.  */
  283.         *mode = M1_ENTER;
  284.         rc_copy(&root, rect);
  285.         return (NIL);
  286.         }
  287.                     /* What object is mouse over?      */
  288.                     /* (Hit is guaranteed.)           */
  289.     hot_obj = objc_find(tree, ROOT, MAX_DEPTH, mx, my);
  290.                     /* Is this object a hot-spot?      */
  291.     state = tree[hot_obj].States();
  292.     if (tree[hot_obj].Flags() & SELECTABLE)
  293.     if ( !(state & DISABLED) )
  294.         {            /* Yes!  Set up wait state.      */
  295.         *mode = M1_EXIT;
  296.         objc_xywh(tree, hot_obj, rect);
  297.         if (state & SELECTED)    /* But only toggle if it's not      */
  298.             return (NIL);    /* already SELECTED!          */
  299.         else
  300.             {
  301.             return (hot_obj);
  302.             }
  303.         }
  304.  
  305.     rc_copy(&root, &br_rect);    /* No hot object, so compute    */
  306.     br_mx = mx;            /* mouse bounding rectangle.    */
  307.     br_my = my;
  308.     br_togl = 0;
  309.     map_tree(tree, ROOT, NIL, break_obj);
  310.     rc_copy(&br_rect, rect);    /* Then return to wait state.    */
  311.     *mode = M1_EXIT;
  312.     return (NIL);
  313. }
  314.  
  315. /************* Keyboard manager and subroutines ***************/
  316.  
  317. /* Check if the object is DEFAULT    */
  318. static int find_def(GEMrawobject* tree, int obj)
  319.     {            /* Is sub-tree hidden?            */
  320.     if (HIDETREE & tree[obj].Flags())
  321.         return (FALSE);
  322.                 /* Must be DEFAULT and not DISABLED    */
  323.     if (DEFAULT & tree[obj].Flags())
  324.     if ( !(DISABLED & tree[obj].States()) )
  325.         fn_obj = obj;    /* Record object number            */
  326.     return (TRUE);
  327. }
  328.  
  329. /* Look for target of TAB operation.    */
  330. static int find_tab(GEMrawobject* tree, int obj)
  331.     {            /* Check for hiddens subtree.        */
  332.     if (HIDETREE & tree[obj].Flags())
  333.         return (FALSE);
  334.                 /* If not EDITABLE, who cares?        */
  335.     if ( !(EDITABLE & tree[obj].Flags()) )
  336.         return (TRUE);
  337.                 /* Check for forward tab match        */
  338.     if (fn_dir && fn_prev == fn_last)
  339.         fn_obj = obj;
  340.                 /* Check for backward tab match        */
  341.     if (!fn_dir && obj == fn_last)
  342.         fn_obj = fn_prev;
  343.     fn_prev = obj;        /* Record object for next call.        */
  344.     return (TRUE);
  345. }    
  346.  
  347. static int form_keyboard(GEMrawobject* tree, int edit_obj, int next_obj, int kr, int *out_obj, int *okr)
  348. {
  349.     if (kr&0xff)        /* If lower byte valid, mask out    */
  350.         kr &= 0xff;    /* extended code byte.            */
  351.     fn_dir = 0;        /* Default tab direction if backward.    */
  352.     switch (kr) {
  353.         case CR:
  354.                 /* Look for a DEFAULT object.        */
  355.             fn_obj = NIL;
  356.             map_tree(tree, ROOT, NIL, find_def);
  357.                 /* If found, SELECT and force exit.    */
  358.             if (fn_obj != NIL) {
  359.                 *okr = 0;    /* Zap character.            */
  360.                 objc_sel(tree, fn_obj);
  361.                 *out_obj = fn_obj;
  362.                 return (FALSE);
  363.             }        /* Falls through to     */ 
  364.         case TAB:            /* tab if no default     */
  365.         case DOWN:    
  366.             fn_dir = 1;        /* Set fwd direction     */
  367.         case BTAB:
  368.         case UP:
  369.             fn_last = edit_obj;
  370.             fn_prev = fn_obj = NIL; /* Look for TAB object    */
  371.             map_tree(tree, ROOT, NIL, find_tab);
  372.             if (fn_obj == NIL)    /* try to wrap around     */
  373.                 map_tree(tree, ROOT, NIL, find_tab);
  374.             if (fn_obj != NIL) {
  375.                 *out_obj = fn_obj;
  376.                 *okr = 0;        /* Zap character    */
  377.             }
  378.             break;
  379.         default:            /* Pass other chars    */
  380.             return (TRUE);
  381.         }
  382.     return (TRUE);
  383. }
  384.  
  385. /************* Mouse button manager and subroutines ***************/
  386.  
  387. static void do_radio(GEMrawobject* tree, int obj)
  388. {
  389.     GRect    root;
  390.     int    pobj, sobj;
  391.  
  392.     objc_xywh(tree, ROOT, &root);
  393.     pobj = get_parent(tree, obj);        /* Get the object's parent */
  394.  
  395.     for (sobj = tree[pobj].Head(); sobj != pobj;
  396.         sobj = tree[sobj].Next() )
  397.         {                /* Deselect all but...       */
  398.         if (sobj != obj)
  399.             objc_dsel(tree, sobj);
  400.         }
  401.     objc_sel(tree, obj);            /* the one being SELECTED  */
  402. }
  403.  
  404. /* Mouse button handler       */
  405. static int form_butn(GEMrawobject* tree, int obj, int clicks, int *next_obj, int *hot_obj)
  406. {
  407.     int    flags, state, hibit, texit, sble, dsbld, edit;
  408.     int    in_state;
  409.  
  410.     flags = tree[obj].Flags();        /* Get flags and states   */
  411.     state = tree[obj].States();
  412.     texit = flags & TOUCHEXIT;
  413.     sble = flags & SELECTABLE;
  414.     dsbld = state & DISABLED;
  415.     edit = flags & EDITABLE;
  416.  
  417.     if (!texit && (!sble || dsbld) && !edit) /* This is not an      */
  418.         {                 /* interesting object    */
  419.         *next_obj = 0;
  420.         return (TRUE);
  421.         }
  422.  
  423.     if (texit && clicks == 2)        /* Preset special flag    */
  424.         hibit = 0x8000;
  425.     else
  426.         hibit = 0x0;
  427.  
  428.     if (sble && !dsbld)            /* Hot stuff!        */
  429.         {
  430.         if (flags & RBUTTON)        /* Process radio buttons*/
  431.             do_radio(tree, obj);    /* immediately!        */ 
  432.         else if (!texit)
  433.             {
  434.             in_state = (obj == *hot_obj)?    /* Already toggled ? */
  435.             state: state ^ SELECTED;    
  436.  
  437.             if (!graf_watchbox(tree, obj, in_state, 
  438.                 in_state ^ SELECTED))
  439.                 {            /* He gave up...  */
  440.                 *next_obj = 0;
  441.                 *hot_obj = NIL;
  442.                 return (TRUE);
  443.                 }
  444.             }
  445.         else /* if (texit) */
  446.             if (obj != *hot_obj)    /* Force SELECTED    */
  447.                 objc_toggle(tree, obj);
  448.         }
  449.  
  450.     if (obj == *hot_obj)        /* We're gonna do it! So don't    */
  451.         *hot_obj = NIL;        /* turn it off later.        */
  452.  
  453.     if (texit || (flags & EXIT) )    /* Exit conditions.        */
  454.         {
  455.         *next_obj = obj | hibit;
  456.         return (FALSE);        /* Time to leave!        */
  457.         }
  458.     else if (!edit)            /* Clear object unless tabbing    */
  459.         *next_obj = 0;
  460.  
  461.     return (TRUE);
  462. }
  463.  
  464. static int to_find;
  465. static int FindToFind(GEMrawobject* o, int i)
  466. {
  467.     return i==to_find ? i : -1;
  468. }
  469.  
  470.  
  471. /************* New forms manager: main loop *************/
  472.  
  473. int GEMhotform::FormDo()
  474. {
  475.     int    edit_obj;
  476.     int        next_obj, hot_obj, hot_mode;
  477.     int        which, cont;
  478.     int        idx;
  479.     int        mx, my, mb, meta, kr, br;
  480.     GRect        hot_rect;
  481.  
  482.     wind_update(BEG_MCTRL);
  483.  
  484.     /* Init. editing    */
  485.     to_find=curedit;
  486.     if (Map(FindToFind)!=to_find) // Is it hidden?
  487.         curedit=Map(FindEdit);
  488.     next_obj = curedit;
  489.     edit_obj = 0;
  490.                         /* Initial hotspot cndx */
  491.     hot_obj = NIL; hot_mode = M1_ENTER;
  492.     objc_xywh(Obj, ROOT, &hot_rect);
  493.                         /* Main event loop    */
  494.     cont = TRUE;
  495.     while (cont) {
  496.                         /* position cursor on    */
  497.                         /*   the selected     */
  498.                         /*   editting field    */
  499.         if (edit_obj!=next_obj && next_obj!=0) {
  500.             edit_obj = next_obj;
  501.             next_obj = 0;
  502.             objc_edit(Obj, edit_obj, 0, idx, EDINIT, &idx);
  503.         }
  504.                         /* wait for button or   */
  505.                         /* key or rectangle    */
  506.         which = evnt_multi(MU_KEYBD | MU_BUTTON | MU_M1, 
  507.             0x01, // WWA - Only single click - else race can occur between clicks
  508.             0x01, 0x01,
  509.             hot_mode, hot_rect.g_x, hot_rect.g_y, 
  510.                 hot_rect.g_w, hot_rect.g_h, 
  511.             0, 0, 0, 0, 0,
  512.             0x0L,
  513.             0,
  514.             &mx, &my, &mb, &meta, &kr, &br);
  515.  
  516.         if (which & MU_M1) {            /* handle rect. event     */
  517.             if (hot_obj != NIL) {
  518.                 int h=DoHot(hot_obj,FALSE);
  519.                 if (h!=Ignore) {
  520.                     next_obj=h;
  521.                     cont=FALSE;
  522.                 }
  523.             }
  524.  
  525.             if (cont) {
  526.                 hot_obj = form_hot(Obj, hot_obj, mx, my, &hot_rect, &hot_mode);
  527.  
  528.                 if (hot_obj != NIL) {
  529.                     int h=DoHot(hot_obj,TRUE);
  530.                     if (h!=Ignore) {
  531.                         next_obj=h;
  532.                         cont=FALSE;
  533.                     }
  534.                 }
  535.             }
  536.         }
  537.  
  538.         if (which & MU_KEYBD) { /* handle keyboard event*/
  539.             /* Control char filter    */
  540.             cont = form_keyboard(Obj, edit_obj, next_obj, kr, &next_obj, &kr);
  541.             if (kr) {
  542.                 int k=DoKey(meta,kr);
  543.                 if (k!=Ignore) {
  544.                     next_obj=k;
  545.                     cont=FALSE;
  546.                 } else {
  547.                     if (edit_obj>0) {
  548.                         objc_edit(Obj, edit_obj, kr, idx, EDCHAR, &idx);
  549.                     }
  550.                 }
  551.             }
  552.           }
  553.                         /* handle button event    */
  554.         if (which & MU_BUTTON) {
  555.             /* Which object hit?    */
  556.             next_obj = objc_find(Obj, ROOT, MAX_DEPTH, mx, my);
  557.              if (next_obj == NIL) {
  558.                 next_obj = DoOff();
  559.                 if (next_obj==NoObject) {
  560.                     cont = FALSE; // We want non-form click to cancel form
  561.                 }
  562.             } else {
  563.                     /* Process a click    */
  564.                 // UnHot the object, rather than expecting form_butn to deal with it.
  565.                 if (hot_obj != NIL) {
  566.                     DoHot(hot_obj,FALSE);
  567.                     hot_obj=NIL;
  568.                 }
  569.                 cont = form_butn(Obj, next_obj, br, &next_obj, &hot_obj);
  570.             }
  571.           }
  572.                         /* handle end of field    */
  573.                         /*   clean up        */
  574.         if (!cont || (next_obj != edit_obj && next_obj != 0))
  575.         if (edit_obj != 0) 
  576.           objc_edit(Obj, edit_obj, 0, idx, EDEND, &idx);
  577.     }
  578.                         /* If defaulted, may    */
  579.                         /* need to clear hotspot*/
  580.     if (hot_obj != (next_obj & 0x7fff))
  581.         if (hot_obj != NIL)
  582.             DoHot(hot_obj,FALSE);
  583.                         /* return exit object    */
  584.                         /*   hi bit may be set    */
  585.                         /*   if exit obj. was    */
  586.                         /*   double-clicked    */
  587.     curedit = edit_obj;
  588.  
  589.     wind_update(END_MCTRL);
  590.  
  591.     return(next_obj);
  592. }
  593.